#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#include "cJSON.h"

// 心跳配置
typedef struct {
    int interval;          // 心跳间隔（秒）
    int timeout;           // 超时时间（秒）
    int enabled;           // 是否启用心跳
    pthread_t thread;      // 心跳线程
    int stop;              // 停止标志
    int (*sendHeartbeat)(void *);  // 发送心跳函数
    void *context;         // 上下文
} HeartbeatConfig;

// 连接状态
typedef struct {
    time_t lastHeartbeat;  // 最后一次收到心跳的时间
    int status;            // 连接状态：0-断开，1-连接
} ConnectionStatus;

// 发送心跳包
static int sendHeartbeatPacket(int sockfd) {
    cJSON *root = cJSON_CreateObject();
    cJSON_AddStringToObject(root, "type", "heartbeat");
    cJSON_AddNumberToObject(root, "timestamp", time(NULL));
    
    char *jsonStr = cJSON_PrintUnformatted(root);
    int ret = send(sockfd, jsonStr, strlen(jsonStr), 0);
    
    cJSON_free(jsonStr);
    cJSON_Delete(root);
    
    return ret;
}

// 心跳线程函数
static void *heartbeatThread(void *arg) {
    HeartbeatConfig *config = (HeartbeatConfig *)arg;
    
    while (!config->stop) {
        sleep(config->interval);
        
        if (config->stop) {
            break;
        }
        
        if (config->sendHeartbeat) {
            config->sendHeartbeat(config->context);
        }
    }
    
    return NULL;
}

// 初始化心跳配置
HeartbeatConfig *heartbeatInit(int interval, int timeout, int (*sendFunc)(void *), void *context) {
    HeartbeatConfig *config = (HeartbeatConfig *)malloc(sizeof(HeartbeatConfig));
    if (!config) {
        return NULL;
    }
    
    config->interval = interval;
    config->timeout = timeout;
    config->enabled = 0;
    config->stop = 0;
    config->sendHeartbeat = sendFunc;
    config->context = context;
    
    return config;
}

// 启动心跳
int heartbeatStart(HeartbeatConfig *config) {
    if (!config || config->enabled) {
        return -1;
    }
    
    config->stop = 0;
    config->enabled = 1;
    
    if (pthread_create(&config->thread, NULL, heartbeatThread, config) != 0) {
        config->enabled = 0;
        return -1;
    }
    
    return 0;
}

// 停止心跳
void heartbeatStop(HeartbeatConfig *config) {
    if (!config || !config->enabled) {
        return;
    }
    
    config->stop = 1;
    config->enabled = 0;
    
    pthread_join(config->thread, NULL);
}

// 销毁心跳配置
void heartbeatDestroy(HeartbeatConfig *config) {
    if (!config) {
        return;
    }
    
    heartbeatStop(config);
    free(config);
}

// 初始化连接状态
ConnectionStatus *connectionStatusInit() {
    ConnectionStatus *status = (ConnectionStatus *)malloc(sizeof(ConnectionStatus));
    if (!status) {
        return NULL;
    }
    
    status->lastHeartbeat = 0;
    status->status = 0;
    
    return status;
}

// 更新连接状态
void connectionStatusUpdate(ConnectionStatus *status) {
    if (!status) {
        return;
    }
    
    status->lastHeartbeat = time(NULL);
    status->status = 1;
}

// 检查连接是否超时
int connectionStatusCheckTimeout(ConnectionStatus *status, int timeout) {
    if (!status) {
        return 1;  // 默认超时
    }
    
    if (time(NULL) - status->lastHeartbeat > timeout) {
        status->status = 0;
        return 1;  // 超时
    }
    
    return 0;  // 未超时
}

// 获取连接状态
int connectionStatusGet(ConnectionStatus *status) {
    if (!status) {
        return 0;
    }
    
    return status->status;
}

// 销毁连接状态
void connectionStatusDestroy(ConnectionStatus *status) {
    if (status) {
        free(status);
    }
}